package org.example.controller;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * Spring Batch 控制器 - 教学版本
 * 
 * 这个控制器演示了如何通过 REST API 来触发 Spring Batch 任务
 * 
 * 核心组件说明：
 * 1. JobLauncher：任务启动器，负责启动和管理Job的执行
 * 2. Job：批处理作业，包含具体的处理逻辑
 * 3. JobParameters：作业参数，用于传递执行时需要的参数
 * 
 * 设计模式：
 * - 使用 REST API 提供外部触发接口
 * - 异步执行：批处理任务在后台异步执行，不阻塞HTTP请求
 * - 统一响应格式：所有接口返回统一的JSON格式
 * 
 * 实际应用场景：
 * - 定时任务触发：通过调度系统调用API触发批处理
 * - 手动触发：管理员手动触发批处理任务
 * - 事件驱动：系统事件触发批处理（如文件上传完成）
 * - 外部系统集成：其他系统通过API触发批处理
 * 
 * @author example
 */
@RestController
@RequestMapping("/batch")
public class BatchController {

    /**
     * JobLauncher：Spring Batch 的任务启动器
     * 
     * 主要功能：
     * - 启动Job执行
     * - 管理Job的生命周期
     * - 提供异步和同步执行模式
     * - 处理Job参数和上下文
     * 
     * 默认实现：SimpleJobLauncher
     * - 使用TaskExecutor执行任务（可配置为同步或异步）
     * - 支持事务管理
     * - 提供执行状态监控
     */
    @Autowired
    private JobLauncher jobLauncher;

    /**
     * 简单任务 Job
     * 使用 @Qualifier 注解明确指定要注入的Bean
     * 这样可以避免多个同类型Bean的冲突
     */
    @Autowired
    @Qualifier("simpleJob")
    private Job simpleJob;

    /**
     * 数据处理任务 Job
     * 演示基于Chunk模式的数据处理
     */
    @Autowired
    @Qualifier("dataProcessingJob")
    private Job dataProcessingJob;

    /**
     * 学生批处理任务 Job
     * 演示复杂业务对象的批处理
     */
    @Autowired
    @Qualifier("studentBatchJob")
    private Job studentBatchJob;

    /**
     * 大数据量学生批处理任务 Job
     * 演示从数据库分页读取大量数据的批处理
     */
    @Autowired
    @Qualifier("bigDataStudentJob")
    private Job bigDataStudentJob;

    /**
     * MyBatis版本的学生批处理任务 Job
     * 演示Spring Batch与MyBatis的完美集成
     */
    @Autowired
    @Qualifier("myBatisStudentJob")
    private Job myBatisStudentJob;

    /**
     * 触发简单的批处理任务 - 演示 Tasklet 模式
     * 
     * URL: GET /batch/simple
     * 
     * 这个接口演示了如何启动一个基于 Tasklet 的简单批处理任务
     * 
     * JobParameters 的重要性：
     * - Spring Batch 使用 JobParameters 来区分不同的 Job 实例
     * - 相同的 Job 名称 + 相同的参数 = 同一个 Job 实例
     * - 如果Job实例已经成功执行过，再次执行会抛出异常
     * - 因此每次执行都需要提供不同的参数（如时间戳）
     * 
     * 异步执行说明：
     * - JobLauncher 默认是异步执行的
     * - HTTP 请求会立即返回，不等待批处理完成
     * - 批处理任务在后台继续执行
     * - 如果需要同步执行，可以配置 JobLauncher 的 TaskExecutor
     * 
     * @return 执行结果的 JSON 响应
     */
    @GetMapping("/simple")
    public Map<String, Object> runSimpleJob() {
        Map<String, Object> result = new HashMap<>();
        try {
            System.out.println("收到简单批处理任务执行请求");
            
            // 创建任务参数（每次执行需要不同的参数以避免重复执行）
            // 这里使用当前时间戳确保每次参数都不同
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("time", System.currentTimeMillis()) // 时间戳参数
                    .addString("jobType", "simple") // 任务类型标识
                    .toJobParameters();

            System.out.println("启动简单批处理任务，参数: " + jobParameters.toString());

            // 启动任务
            // 注意：这里是异步执行，方法会立即返回
            // 实际的批处理逻辑会在后台线程中执行
            jobLauncher.run(simpleJob, jobParameters);
            
            // 构建成功响应
            result.put("status", "success");
            result.put("message", "简单批处理任务已成功启动（异步执行中）");
            result.put("jobName", "simpleJob");
            result.put("description", "基于 Tasklet 模式的简单批处理任务");
            result.put("timestamp", System.currentTimeMillis());
            
            System.out.println("简单批处理任务启动成功");
            
        } catch (Exception e) {
            System.err.println("启动简单批处理任务失败: " + e.getMessage());
            e.printStackTrace();
            
            // 构建错误响应
            result.put("status", "error");
            result.put("message", "启动批处理任务失败: " + e.getMessage());
            result.put("error", e.getClass().getSimpleName());
            result.put("timestamp", System.currentTimeMillis());
        }
        
        return result;
    }

    /**
     * 触发数据处理批处理任务 - 演示 Chunk 模式
     * 
     * URL: GET /batch/data-processing
     * 
     * 这个接口演示了基于 Chunk 模式的数据处理批处理任务
     * 
     * Chunk 模式特点：
     * - Reader-Processor-Writer 架构
     * - 分批处理：每次处理 chunk 大小的数据量
     * - 事务控制：每个 chunk 作为一个事务
     * - 内存友好：不会一次性加载全部数据
     * 
     * 本示例处理流程：
     * 1. Reader 从内存列表读取 20 条字符串数据
     * 2. Processor 对每条数据添加"已处理_"前缀
     * 3. Writer 批量输出处理后的数据
     * 4. chunk 大小设置为 10，所以会分 2 个批次处理
     * 
     * 实际应用场景：
     * - 大量数据的 ETL 处理
     * - 数据迁移和转换
     * - 批量数据清洗
     * - 报表数据生成
     * 
     * @return 执行结果的 JSON 响应
     */
    @GetMapping("/data-processing")
    public Map<String, Object> runDataProcessingJob() {
        Map<String, Object> result = new HashMap<>();
        try {
            System.out.println("收到数据处理批处理任务执行请求");
            
            // 创建任务参数
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("time", System.currentTimeMillis()) // 确保每次执行参数不同
                    .addString("jobType", "dataProcessing") // 任务类型标识
                    .addLong("dataCount", 20L) // 数据数量参数
                    .addLong("chunkSize", 10L) // 分块大小参数
                    .toJobParameters();

            System.out.println("启动数据处理批处理任务，参数: " + jobParameters.toString());

            // 启动任务
            jobLauncher.run(dataProcessingJob, jobParameters);
            
            // 构建成功响应
            result.put("status", "success");
            result.put("message", "数据处理批处理任务已成功启动（异步执行中）");
            result.put("jobName", "dataProcessingJob");
            result.put("description", "基于 Reader-Processor-Writer 模式的数据处理任务");
            result.put("processingInfo", "将处理 20 条字符串数据，分 2 个批次（每批次 10 条）");
            result.put("timestamp", System.currentTimeMillis());
            
            System.out.println("数据处理批处理任务启动成功");
            
        } catch (Exception e) {
            System.err.println("启动数据处理批处理任务失败: " + e.getMessage());
            e.printStackTrace();
            
            // 构建错误响应
            result.put("status", "error");
            result.put("message", "启动批处理任务失败: " + e.getMessage());
            result.put("error", e.getClass().getSimpleName());
            result.put("timestamp", System.currentTimeMillis());
        }
        
        return result;
    }

    /**
     * 触发学生批处理任务 - 演示复杂业务对象处理
     * 
     * URL: GET /batch/student
     * 
     * 这个接口演示了处理复杂业务对象的批处理任务
     * 
     * 业务场景模拟：
     * - 对学生数据进行批量处理
     * - 根据年龄对学生进行分类标记
     * - 演示完整的数据处理链路
     * 
     * 处理流程：
     * 1. Reader 读取 5 个学生的基础信息
     * 2. Processor 根据年龄进行分类处理：
     *    - 18岁以下：[未成年]
     *    - 18-25岁：[青年]  
     *    - 25岁以上：[成年]
     * 3. Writer 批量输出处理后的学生信息
     * 4. chunk 大小设置为 5，一次性处理所有学生
     * 
     * 学习要点：
     * - 复杂对象的批处理
     * - 业务规则的应用
     * - 数据验证和处理
     * - 批处理中的错误处理
     * 
     * 实际应用扩展：
     * - 可以从数据库读取学生信息
     * - 可以调用外部API获取补充数据
     * - 可以将处理结果写入数据库或文件
     * - 可以发送处理结果到消息队列
     * 
     * @return 执行结果的 JSON 响应
     */
    @GetMapping("/student")
    public Map<String, Object> runStudentBatchJob() {
        Map<String, Object> result = new HashMap<>();
        try {
            System.out.println("收到学生数据批处理任务执行请求");
            
            // 创建任务参数
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("time", System.currentTimeMillis()) // 确保每次执行参数不同
                    .addString("jobType", "studentBatch") // 任务类型标识
                    .addLong("studentCount", 5L) // 学生数量参数
                    .addString("processType", "ageClassification") // 处理类型
                    .toJobParameters();

            System.out.println("启动学生数据批处理任务，参数: " + jobParameters.toString());

            // 启动任务
            jobLauncher.run(studentBatchJob, jobParameters);
            
            // 构建成功响应
            result.put("status", "success");
            result.put("message", "学生数据批处理任务已成功启动（异步执行中）");
            result.put("jobName", "studentBatchJob");
            result.put("description", "演示复杂业务对象的批处理，根据年龄对学生进行分类标记");
            result.put("processingInfo", "将处理 5 个学生的数据，根据年龄进行分类标记");
            result.put("businessLogic", "未成年(<18) | 青年(18-25) | 成年(>25)");
            result.put("timestamp", System.currentTimeMillis());
            
            System.out.println("学生数据批处理任务启动成功");
            
        } catch (Exception e) {
            System.err.println("启动学生数据批处理任务失败: " + e.getMessage());
            e.printStackTrace();
            
            // 构建错误响应
            result.put("status", "error");
            result.put("message", "启动批处理任务失败: " + e.getMessage());
            result.put("error", e.getClass().getSimpleName());
            result.put("timestamp", System.currentTimeMillis());
        }
        
        return result;
    }

    /**
     * 触发大数据量学生批处理任务 - 演示数据库分页读取
     * 
     * URL: GET /batch/big-data-student
     * 
     * 这个接口演示了处理大数据量的批处理任务，是生产环境中最常见的应用场景
     * 
     * 技术特点：
     * - 数据库分页读取：使用JdbcPagingItemReader从数据库分页获取数据
     * - 内存友好：不会一次性加载全部数据到内存
     * - 高性能处理：优化的处理逻辑和批量写入
     * - 容错机制：跳过异常记录，确保任务稳定性
     * - 实时监控：提供详细的执行统计和性能指标
     * 
     * 配置详解：
     * - PageSize: 500 （每次从数据库读取500条记录）
     * - ChunkSize: 100 （每100条记录提交一次事务）
     * - FetchSize: 1000 （JDBC fetch大小，优化网络传输）
     * - SkipLimit: 10 （最多跳过10条异常记录）
     * 
     * 处理流程：
     * 1. JdbcPagingItemReader 按ID排序分页读取学生数据
     * 2. BigDataStudentProcessor 进行数据清洗、验证和业务处理
     * 3. BigDataStudentWriter 批量输出处理结果
     * 4. BigDataJobExecutionListener 提供全程监控和统计
     * 
     * 性能优化：
     * - 数据库索引：确保ID字段有索引支持高效排序
     * - 连接池配置：合理配置数据库连接池大小
     * - JVM参数：调整堆内存大小适应处理数据量
     * - 监控调优：根据统计信息调整chunk大小和page大小
     * 
     * 实际应用场景：
     * - 学生信息的批量数据清洗和标准化
     * - 学籍数据的定期同步和更新
     * - 成绩数据的批量计算和统计
     * - 毕业生信息的批量导出和归档
     * - 数据质量检查和修复
     * 
     * 扩展建议：
     * - 分区处理：对于超大数据量，可以按年级、专业等字段分区并行处理
     * - 增量处理：基于更新时间字段实现增量数据处理
     * - 定时调度：集成Quartz等调度框架实现定时执行
     * - 监控报警：集成监控系统，实现异常情况自动报警
     * - 数据备份：处理前后的数据备份和恢复机制
     * 
     * @return 执行结果的 JSON 响应
     */
    @GetMapping("/big-data-student")
    public Map<String, Object> runBigDataStudentJob() {
        Map<String, Object> result = new HashMap<>();
        try {
            System.out.println("收到大数据量学生批处理任务执行请求");
            
            // 创建任务参数
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("time", System.currentTimeMillis()) // 确保每次执行参数不同
                    .addString("jobType", "bigDataStudent") // 任务类型标识
                    .addString("dataSource", "database") // 数据源类型
                    .addLong("pageSize", 500L) // 分页大小参数
                    .addLong("chunkSize", 100L) // 分块大小参数
                    .addString("processingMode", "production") // 处理模式
                    .toJobParameters();

            System.out.println("启动大数据量学生批处理任务，参数: " + jobParameters.toString());

            // 启动任务
            jobLauncher.run(bigDataStudentJob, jobParameters);
            
            // 构建成功响应
            result.put("status", "success");
            result.put("message", "大数据量学生批处理任务已成功启动（异步执行中）");
            result.put("jobName", "bigDataStudentJob");
            result.put("description", "从数据库分页读取学生数据进行批量处理，演示生产级别的大数据处理");
            result.put("technicalDetails", new HashMap<String, Object>() {{
                put("dataSource", "MySQL数据库");
                put("readerType", "JdbcPagingItemReader");
                put("pageSize", "500条记录/页");
                put("chunkSize", "100条记录/事务");
                put("fetchSize", "1000（JDBC优化）");
                put("sortKey", "id ASC（确保数据一致性）");
                put("faultTolerant", "是（最多跳过10条异常记录）");
            }});
            result.put("performanceMetrics", new HashMap<String, String>() {{
                put("memoryUsage", "低（分页读取，内存友好）");
                put("transactionControl", "每100条记录提交一次事务");
                put("errorHandling", "跳过异常记录，继续处理");
                put("monitoring", "实时统计和性能监控");
            }});
            result.put("businessLogic", new HashMap<String, String>() {{
                put("dataValidation", "姓名、年龄、邮箱格式验证");
                put("dataCleaning", "去除特殊字符，标准化格式");
                put("dataEnrichment", "根据年龄添加分类标签");
                put("qualityControl", "数据质量检查和异常处理");
            }});
            result.put("timestamp", System.currentTimeMillis());
            
            System.out.println("大数据量学生批处理任务启动成功");
            
        } catch (Exception e) {
            System.err.println("启动大数据量学生批处理任务失败: " + e.getMessage());
            e.printStackTrace();
            
            // 构建错误响应
            result.put("status", "error");
            result.put("message", "启动批处理任务失败: " + e.getMessage());
            result.put("error", e.getClass().getSimpleName());
            result.put("troubleshooting", new HashMap<String, String>() {{
                put("检查数据库连接", "确保MySQL数据库连接正常");
                put("检查表结构", "确保student表存在且结构正确");
                put("检查权限", "确保数据库用户有读取权限");
                put("检查内存", "确保JVM有足够内存执行任务");
            }});
            result.put("timestamp", System.currentTimeMillis());
        }
        
        return result;
    }

    /**
     * 触发MyBatis版本的学生批处理任务 - 演示Spring Batch与MyBatis的完美集成
     * 
     * URL: GET /batch/mybatis-student
     * 
     * 这个接口展示了Spring Batch与MyBatis的深度集成，是企业级开发的首选方案
     * 
     * 🎯 核心特色：
     * - MyBatis XML映射：使用XML映射文件定义复杂SQL查询
     * - 动态SQL支持：可以根据条件动态生成查询语句
     * - 对象关系映射：充分利用MyBatis的ORM能力
     * - 批量操作优化：利用MyBatis的批量插入功能
     * - 缓存机制：可以利用MyBatis的一级和二级缓存
     * 
     * 🛠️ 技术架构：
     * - 数据读取：MyBatisPagingItemReader + XML映射文件
     * - 数据处理：MyBatisStudentProcessor（Student -> StudentProcessed）
     * - 数据写入：MyBatisStudentWriter + 批量插入
     * - 任务监听：MyBatisJobExecutionListener（专业监控）
     * 
     * 📊 处理流程：
     * 1. 从student表分页读取原始数据（使用MyBatis分页查询）
     * 2. 执行数据清洗、验证、分类和质量评分
     * 3. 转换为StudentProcessed对象（包含增强字段）
     * 4. 批量写入student_processed表（使用MyBatis批量插入）
     * 5. 生成详细的统计报告和数据分析
     * 
     * 🚀 性能特点：
     * - 分页读取：pageSize=500，避免内存溢出
     * - 批量处理：chunkSize=100，优化事务性能
     * - 容错机制：最多跳过20条异常记录
     * - 内存友好：流式处理，低内存占用
     * - 高并发：支持多线程并行处理（可扩展）
     * 
     * 📈 业务增强：
     * - 数据质量评分：0-100分质量评估
     * - 年龄智能分类：未成年/青年/成年/中年/老年
     * - 性别标准化：统一为M/F/U格式
     * - 邮箱验证修复：自动修复常见邮箱格式错误
     * - 姓名清洗：去除特殊字符，标准化格式
     * 
     * 🔧 配置详解：
     * - Reader: MyBatisPagingItemReader，基于StudentProcessedMapper.selectStudentsForBatch
     * - Processor: 数据转换（Student -> StudentProcessed）+ 业务处理
     * - Writer: MyBatis批量插入，基于StudentProcessedMapper.batchInsert
     * - 事务: 每100条记录一个事务，确保数据一致性
     * 
     * 💾 数据库操作：
     * - 源表: student（id, name, age, gender, email）
     * - 目标表: student_processed（包含原始数据 + 处理结果 + 质量评分等）
     * - 索引优化: 按source_student_id、batch_number、process_status建立索引
     * - 统计查询: 支持按批次号查询处理统计信息
     * 
     * 🔍 监控功能：
     * - 实时进度：每500条显示处理进度
     * - 性能指标：处理速度、内存使用、事务频率
     * - 数据统计：年龄分布、性别比例、质量评分分析
     * - 数据库统计：通过SQL查询验证处理结果
     * 
     * 🌟 实际应用场景：
     * - 学生信息系统的数据质量提升
     * - 教务系统的数据清洗和标准化
     * - 招生数据的批量处理和分析
     * - 毕业生档案的批量生成和归档
     * - 跨系统数据同步和ETL处理
     * 
     * 🔧 扩展功能建议：
     * - 数据分区：按年级、学院等维度并行处理
     * - 增量处理：基于更新时间实现增量同步
     * - 数据血缘：记录数据转换的完整链路
     * - 质量报告：生成数据质量评估报告
     * - 异常预警：集成监控告警系统
     * 
     * 📚 学习价值：
     * - Spring Batch + MyBatis集成的标准模式
     * - 大数据量处理的性能优化实践
     * - 企业级数据质量管理方案
     * - 分页查询与批量写入的最佳实践
     * - 数据转换和业务处理的设计模式
     * 
     * @return 执行结果的 JSON 响应，包含详细的技术信息和处理统计
     */
    @GetMapping("/mybatis-student")
    public Map<String, Object> runMyBatisStudentJob() {
        Map<String, Object> result = new HashMap<>();
        try {
            System.out.println("收到MyBatis版本学生批处理任务执行请求");
            
            // 创建任务参数
            JobParameters jobParameters = new JobParametersBuilder()
                    .addLong("time", System.currentTimeMillis()) // 确保每次执行参数不同
                    .addString("jobType", "myBatisStudent") // 任务类型标识
                    .addString("dataSource", "myBatisDatabase") // 数据源类型
                    .addLong("pageSize", 500L) // MyBatis分页大小
                    .addLong("chunkSize", 100L) // 分块大小参数
                    .addString("processingMode", "enhanced") // 增强处理模式
                    .addString("targetTable", "student_processed") // 目标表
                    .addString("integrationFramework", "mybatis") // 集成框架
                    .toJobParameters();

            System.out.println("启动MyBatis学生批处理任务，参数: " + jobParameters.toString());

            // 启动任务
            jobLauncher.run(myBatisStudentJob, jobParameters);
            
            // 构建成功响应
            result.put("status", "success");
            result.put("message", "MyBatis版本学生批处理任务已成功启动（异步执行中）");
            result.put("jobName", "myBatisStudentJob");
            result.put("description", "Spring Batch + MyBatis集成的企业级大数据处理方案，演示完整的ETL流程");
            
            // 技术特色
            result.put("technicalFeatures", new HashMap<String, Object>() {{
                put("framework", "Spring Batch + MyBatis");
                put("readerType", "MyBatisPagingItemReader");
                put("processorType", "MyBatisStudentProcessor（数据转换增强）");
                put("writerType", "MyBatisStudentWriter（批量插入）");
                put("listenerType", "MyBatisJobExecutionListener（专业监控）");
                put("mappingFile", "StudentProcessedMapper.xml");
                put("sqlType", "动态SQL + 批量操作");
                put("cacheSupport", "MyBatis一级和二级缓存");
            }});
            
            // 处理配置
            result.put("processingConfiguration", new HashMap<String, Object>() {{
                put("sourceTable", "student");
                put("targetTable", "student_processed");
                put("pageSize", "500条记录/页（MyBatis分页）");
                put("chunkSize", "100条记录/事务");
                put("faultTolerance", "最多跳过20条异常记录");
                put("transactionControl", "每chunk一个事务");
                put("dataMapping", "Student -> StudentProcessed");
            }});
            
            // 业务功能
            result.put("businessCapabilities", new HashMap<String, Object>() {{
                put("dataValidation", "姓名、年龄、邮箱格式全面验证");
                put("dataCleaning", "去除特殊字符，标准化数据格式");
                put("ageClassification", "智能年龄分类（未成年/青年/成年/中年/老年）");
                put("genderStandardization", "性别统一为M/F/U标准格式");
                put("emailValidation", "邮箱格式验证和自动修复");
                put("qualityScoring", "0-100分数据质量评分系统");
                put("batchTracking", "批次号追踪和统计分析");
            }});
            
            // 性能优化
            result.put("performanceOptimization", new HashMap<String, Object>() {{
                put("memoryUsage", "低内存占用（流式处理）");
                put("databaseAccess", "分页读取 + 批量写入");
                put("indexSupport", "多字段索引优化查询性能");
                put("connectionPooling", "数据库连接池复用");
                put("sqlOptimization", "MyBatis SQL优化和缓存");
                put("transactionManagement", "合理的事务边界控制");
            }});
            
            // 监控统计
            result.put("monitoringFeatures", new HashMap<String, Object>() {{
                put("realTimeProgress", "每500条记录显示进度");
                put("performanceMetrics", "处理速度、事务频率监控");
                put("dataDistribution", "年龄分布、性别比例分析");
                put("qualityAnalysis", "数据质量统计和评分分析");
                put("databaseStatistics", "数据库级别的统计查询");
                put("executionSummary", "完整的执行报告和建议");
            }});
            
            // 数据流向
            result.put("dataFlow", new String[]{
                "1. 从student表读取原始数据（MyBatis分页查询）",
                "2. 执行数据验证和清洗（MyBatisStudentProcessor）",
                "3. 进行业务处理和质量评分（年龄分类、性别标准化等）",
                "4. 转换为StudentProcessed对象（包含原始数据+处理结果）",
                "5. 批量写入student_processed表（MyBatis批量插入）",
                "6. 生成详细统计报告和数据分析（数据库查询验证）"
            });
            
            result.put("timestamp", System.currentTimeMillis());
            
            System.out.println("MyBatis学生批处理任务启动成功");
            
        } catch (Exception e) {
            System.err.println("启动MyBatis学生批处理任务失败: " + e.getMessage());
            e.printStackTrace();
            
            // 构建错误响应
            result.put("status", "error");
            result.put("message", "启动MyBatis批处理任务失败: " + e.getMessage());
            result.put("error", e.getClass().getSimpleName());
            result.put("troubleshooting", new HashMap<String, String>() {{
                put("检查数据库连接", "确保MySQL数据库连接正常");
                put("检查表结构", "确保student和student_processed表存在");
                put("检查MyBatis配置", "确认SqlSessionFactory和Mapper配置正确");
                put("检查权限", "确保数据库用户有读写权限");
                put("检查依赖", "确认MyBatis Spring Batch依赖已添加");
            }});
            result.put("timestamp", System.currentTimeMillis());
        }
        
        return result;
    }

    /**
     * 获取批处理系统状态 - 系统信息和接口说明
     * 
     * URL: GET /batch/status
     * 
     * 这个接口提供了批处理系统的整体状态信息和使用指南
     * 
     * 功能说明：
     * - 显示系统运行状态
     * - 列出所有可用的批处理任务
     * - 提供接口使用说明
     * - 展示系统的基本信息
     * 
     * 实际应用中可以扩展为：
     * - 显示当前正在执行的任务
     * - 显示任务执行历史和统计
     * - 提供任务监控和管理功能
     * - 集成健康检查和报警功能
     * 
     * @return 系统状态信息的 JSON 响应
     */
    @GetMapping("/status")
    public Map<String, Object> getBatchStatus() {
        Map<String, Object> result = new HashMap<>();
        
        // 基本状态信息
        result.put("status", "running");
        result.put("message", "Spring Batch 系统正常运行");
        result.put("version", "Spring Boot 2.1.6 + Spring Batch");
        
        // 可用的批处理任务列表
        result.put("availableJobs", new String[]{
            "simpleJob - 简单任务（Tasklet模式）", 
            "dataProcessingJob - 数据处理（Chunk模式）", 
            "studentBatchJob - 学生数据处理（复杂对象）",
            "bigDataStudentJob - 大数据量处理（数据库分页读取）",
            "myBatisStudentJob - MyBatis集成（企业级大数据处理）"
        });
        
        // API 接口说明
        result.put("endpoints", new String[]{
            "GET /batch/simple - 执行简单任务（演示Tasklet模式）",
            "GET /batch/data-processing - 执行数据处理任务（演示Chunk模式）",
            "GET /batch/student - 执行学生数据批处理任务（演示复杂业务处理）",
            "GET /batch/big-data-student - 执行大数据量学生批处理任务（演示生产级大数据处理）",
            "GET /batch/mybatis-student - 执行MyBatis学生批处理任务（演示Spring Batch + MyBatis集成）",
            "GET /batch/status - 获取系统状态和使用说明"
        });
        
        // 学习指南
        result.put("learningGuide", new String[]{
            "1. 先调用 /batch/status 了解系统状态",
            "2. 调用 /batch/simple 体验最简单的批处理（Tasklet模式）",
            "3. 调用 /batch/data-processing 学习数据流处理（Chunk模式基础）",
            "4. 调用 /batch/student 了解业务对象处理（内存数据处理）",
            "5. 调用 /batch/big-data-student 学习生产级大数据处理（数据库分页）",
            "6. 调用 /batch/mybatis-student 掌握企业级MyBatis集成（完整ETL方案）",
            "7. 观察控制台输出了解执行过程和性能统计",
            "8. 对比不同任务的处理方式和性能表现"
        });
        
        // 核心概念说明
        result.put("concepts", new HashMap<String, String>() {{
            put("Job", "批处理作业，包含一个或多个Step");
            put("Step", "作业步骤，可以是Tasklet或Chunk类型");
            put("Tasklet", "简单任务执行器，适合一次性操作");
            put("Chunk", "分块处理，包含Reader-Processor-Writer");
            put("Reader", "数据读取器，从数据源读取数据");
            put("Processor", "数据处理器，执行业务逻辑");
            put("Writer", "数据写入器，将结果写入目标存储");
            put("JdbcPagingItemReader", "数据库分页读取器，支持大数据量处理");
            put("PageSize", "每页读取的记录数，影响内存使用");
            put("ChunkSize", "每个事务处理的记录数，影响性能");
            put("FaultTolerant", "容错机制，跳过异常记录继续处理");
            put("JobListener", "任务监听器，监控任务执行过程");
        }});
        
        result.put("timestamp", System.currentTimeMillis());
        result.put("systemTime", new java.util.Date().toString());
        
        return result;
    }
} 